home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 42 / Amiga Format AFCD42 (Issue 126, Aug 1999).iso / -serious- / programming / other / jikes / src / symbol.h < prev    next >
C/C++ Source or Header  |  1999-05-14  |  73KB  |  2,293 lines
  1. // $Id: symbol.h,v 1.11 1999/03/09 14:37:17 shields Exp $
  2. //
  3. // This software is subject to the terms of the IBM Jikes Compiler
  4. // License Agreement available at the following URL:
  5. // http://www.ibm.com/research/jikes.
  6. // Copyright (C) 1996, 1998, International Business Machines Corporation
  7. // and others.  All Rights Reserved.
  8. // You must accept the terms of that agreement to use this software.
  9. //
  10. #ifndef symbol_INCLUDED
  11. #define symbol_INCLUDED
  12.  
  13. #include "config.h"
  14. #include <assert.h>
  15. #include <stddef.h>
  16. #include <stdio.h>
  17. #include <sys/types.h>
  18. #include <sys/stat.h>
  19. #include <string.h>
  20. #include "code.h"
  21. #include "stream.h"
  22. #include "option.h"
  23. #include "lookup.h"
  24. #include "depend.h"
  25. #include "access.h"
  26. #include "tuple.h"
  27.  
  28. class Semantic;
  29. class SemanticEnvironment;
  30. class Ast;
  31. class AstCompilationUnit;
  32. class AstMethodDeclarator;
  33. class AstBlock;
  34. class AstList;
  35. class AstExpression;
  36. class AstVariableDeclarator;
  37. class ExpandedTypeTable;
  38. class ExpandedFieldTable;
  39. class ExpandedMethodTable;
  40. class SymbolTable;
  41. class SymbolSet;
  42. class Zip;
  43.  
  44. class PackageSymbol;
  45.  
  46. class PathSymbol : public Symbol
  47. { 
  48. public:
  49.     NameSymbol *name_symbol;
  50.     Zip *zipfile;
  51.  
  52.     PathSymbol(NameSymbol *);
  53.     virtual ~PathSymbol();
  54.  
  55.     virtual wchar_t *Name() { return name_symbol -> Name(); }
  56.     virtual int NameLength() { return name_symbol -> NameLength(); }
  57.     virtual NameSymbol *Identity() { return name_symbol; }
  58.     char *Utf8Name() { return (char *) (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> value : NULL); }
  59.     int Utf8NameLength() { return (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> length : 0); }
  60.  
  61.     inline bool IsZip() { return zipfile != NULL; }
  62.  
  63.     inline DirectorySymbol *RootDirectory() { return root_directory; }
  64.  
  65. private:
  66.     friend class SymbolTable;
  67.     DirectorySymbol *root_directory;
  68. };
  69.  
  70.  
  71. class DirectorySymbol : public Symbol
  72. { 
  73. public:
  74.     Symbol *owner;
  75.     NameSymbol *name_symbol;
  76.  
  77.     Tuple<DirectorySymbol *> subdirectories;
  78.  
  79.     DirectorySymbol(NameSymbol *, Symbol *);
  80.     virtual ~DirectorySymbol();
  81.  
  82.     virtual wchar_t *Name() { return name_symbol -> Name(); }
  83.     virtual int NameLength() { return name_symbol -> NameLength(); }
  84.     virtual NameSymbol *Identity() { return name_symbol; }
  85.     char *Utf8Name() { return (char *) (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> value : NULL); }
  86.     int Utf8NameLength() { return (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> length : 0); }
  87.  
  88.     DirectoryEntry *FindEntry(char *name, int len) { return (entries ? entries -> FindEntry(name, len) : (DirectoryEntry *) NULL); }
  89.  
  90. #ifdef WIN32_FILE_SYSTEM
  91.     DirectoryEntry *FindCaseInsensitiveEntry(char *name, int length)
  92.     {
  93.         return entries -> FindCaseInsensitiveEntry(name, length);
  94.     }
  95.  
  96.     void InsertEntry(char *name, int length)
  97.     {
  98.         DirectoryEntry *entry = entries -> InsertEntry((DirectorySymbol *) this, name, length);
  99.         entries -> InsertCaseInsensitiveEntry(entry);
  100.  
  101.         return;
  102.     }
  103. #endif
  104.  
  105.     PathSymbol *PathSym()
  106.     {
  107.         return (owner -> PathCast() ? (PathSymbol *) owner : ((DirectorySymbol *) owner) -> PathSym());
  108.     }
  109.  
  110.     inline bool IsZip() { return PathSym() -> IsZip(); }
  111.  
  112.     void SetDirectoryName();
  113.     inline char *DirectoryName()
  114.     {
  115.         if (! directory_name)
  116.             SetDirectoryName();
  117.         return directory_name;
  118.     }
  119.     inline int DirectoryNameLength()
  120.     {
  121.         if (! directory_name)
  122.             SetDirectoryName();
  123.         return directory_name_length;
  124.     }
  125.  
  126.     inline DirectorySymbol *InsertDirectorySymbol(NameSymbol *);
  127.     inline DirectorySymbol *InsertAndReadDirectorySymbol(NameSymbol *);
  128.     inline DirectorySymbol *FindDirectorySymbol(NameSymbol *);
  129.  
  130.     inline FileSymbol *InsertFileSymbol(NameSymbol *);
  131.     inline FileSymbol *FindFileSymbol(NameSymbol *);
  132.  
  133.     void ResetDirectory();
  134.  
  135. private:
  136.  
  137.     time_t mtime;
  138.  
  139.     void ReadDirectory();
  140.  
  141.     SymbolTable *table;
  142.     inline SymbolTable *Table();
  143.  
  144.     DirectoryTable *entries;
  145.     char *directory_name;
  146.     int directory_name_length;
  147. };
  148.  
  149.  
  150. class FileSymbol : public Symbol
  151. { 
  152. private:
  153.     enum FileKind
  154.     {
  155.         JAVA,
  156.         CLASS,
  157.         CLASS_ONLY
  158.     };
  159.  
  160.     DirectorySymbol *output_directory;
  161.     char *file_name;
  162.     int file_name_length;
  163.  
  164. public:
  165.     NameSymbol *name_symbol;
  166.     DirectorySymbol *directory_symbol;
  167.     PackageSymbol *package;
  168.     FileKind kind;
  169.  
  170.     //
  171.     // These fields are used for files in zip packages.
  172.     //
  173.     u4 uncompressed_size;
  174.     u4 date_time;
  175.     long offset;
  176.  
  177.     //
  178.     // This field holds the time of last data modification for a non-zip file
  179.     //
  180.     time_t mtime;
  181.  
  182.     LexStream *lex_stream;
  183.     AstCompilationUnit *compilation_unit;
  184.     Semantic *semantic;
  185.  
  186.     Tuple<TypeSymbol *> types;
  187.  
  188.     FileSymbol(NameSymbol *name_symbol_, NameSymbol *dirname_symbol = NULL) : name_symbol(name_symbol_),
  189.                                                                               output_directory(NULL),
  190.                                                                               directory_symbol(NULL),
  191.                                                                               package(NULL),
  192.                                                                               file_name(NULL),
  193.                                                                               mtime(0),
  194.                                                                               lex_stream(NULL),
  195.                                                                               compilation_unit(NULL),
  196.                                                                               semantic(NULL),
  197.                                                                               types(4)
  198.     {
  199.          Symbol::_kind = _FILE;
  200.     }
  201.  
  202.     virtual ~FileSymbol()
  203.     {
  204.         delete [] file_name;
  205.         delete lex_stream;
  206.     }
  207.  
  208.     FileSymbol *Clone()
  209.     {
  210.         FileSymbol *clone = new FileSymbol(name_symbol);
  211.  
  212.         clone -> kind = kind;
  213.         clone -> directory_symbol = directory_symbol;
  214.         clone -> mtime = mtime;
  215.  
  216.         return clone;
  217.     }
  218.  
  219.     virtual wchar_t *Name() { return name_symbol -> Name(); }
  220.     virtual int NameLength() { return name_symbol -> NameLength(); }
  221.     virtual NameSymbol *Identity() { return name_symbol; }
  222.     char *Utf8Name() { return (char *) (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> value : NULL); }
  223.     int Utf8NameLength() { return (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> length : 0); }
  224.  
  225.     inline void SetJava()       { kind = JAVA; }
  226.     inline void SetClass()      { kind = CLASS; }
  227.     inline void SetClassOnly()  { kind = CLASS_ONLY; }
  228.  
  229.     inline bool IsJava()       { return kind == JAVA; }
  230.     inline bool IsClass()      { return kind >= CLASS; }
  231.     inline bool IsClassOnly()  { return kind == CLASS_ONLY; }
  232.  
  233.     PathSymbol *PathSym()
  234.     {
  235.         return directory_symbol -> PathSym();
  236.     }
  237.     inline bool IsZip() { return PathSym() -> IsZip(); }
  238.     inline Zip *Zipfile() { return PathSym() -> zipfile; }
  239.  
  240.     static char *java_suffix;
  241.     static int java_suffix_length;
  242.     static char *class_suffix;
  243.     static int class_suffix_length;
  244.     static inline bool IsJavaSuffix(char *ptr);
  245.     static inline bool IsClassSuffix(char *ptr);
  246.  
  247.     inline char *FileName()
  248.     {
  249.         if (! file_name)
  250.             SetFileName();
  251.         return file_name;
  252.     }
  253.     inline int FileNameLength()
  254.     {
  255.         if (! file_name)
  256.             SetFileName();
  257.         return file_name_length;
  258.     }
  259.  
  260.     DirectorySymbol *OutputDirectory();
  261.  
  262.     void SetFileName();
  263.  
  264.     void CleanUp();
  265.  
  266.     void Reset()
  267.     {
  268.         CleanUp();
  269.  
  270.         delete [] file_name;
  271.         file_name = NULL;
  272.         types.Reset();
  273.     }
  274. };
  275.  
  276.  
  277. class FileLocation
  278. { 
  279. public:
  280.     wchar_t *location;
  281.  
  282.     FileLocation (LexStream *lex_stream, LexStream::TokenIndex token_index)
  283.     {
  284.         char *file_name = lex_stream -> FileName();
  285.         int length = lex_stream -> FileNameLength();
  286.         location = new wchar_t[length + 13];
  287.         for (int i = 0; i < length; i++) {
  288.             location[i] = (wchar_t) file_name[i];
  289.         }
  290.         location[length++] = U_COLON;
  291.  
  292.         char str[13];
  293.         sprintf(str, "%i", lex_stream -> Line(token_index));
  294.         for (int j = 0; str[j]; j++)
  295.             location[length++] = str[j];
  296.         location[length] = U_NULL;
  297.  
  298.         return;
  299.     }
  300.  
  301.     FileLocation (FileSymbol *file_symbol)
  302.     {
  303.         char *file_name = file_symbol -> FileName();
  304.         int length = file_symbol -> FileNameLength();
  305.         location = new wchar_t[length + 13];
  306.         for (int i = 0; i < length; i++) {
  307.             location[i] = (wchar_t) file_name[i];
  308.         }
  309.         location[length] = U_NULL;
  310.  
  311.         return;
  312.     }
  313.  
  314.     ~FileLocation()
  315.     {
  316.         delete [] location;
  317.     }
  318. };
  319.  
  320.  
  321. class PackageSymbol : public Symbol
  322. { 
  323. public:
  324.     Tuple<DirectorySymbol *> directory;
  325.     PackageSymbol *owner;
  326.  
  327.     PackageSymbol(NameSymbol *name_symbol_, PackageSymbol *owner_) : name_symbol(name_symbol_),
  328.                                                                      directory(4),
  329.                                                                      owner(owner_),
  330.                                                                      package_name(NULL),
  331.                                                                      table(NULL)
  332.     {
  333.         Symbol::_kind = PACKAGE;
  334.     }
  335.  
  336.     virtual ~PackageSymbol();
  337.  
  338.     virtual wchar_t *Name() { return name_symbol -> Name(); }
  339.     virtual int NameLength() { return name_symbol -> NameLength(); }
  340.     virtual NameSymbol *Identity() { return name_symbol; }
  341.     char *Utf8Name() { return (char *) (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> value : NULL); }
  342.     int Utf8NameLength() { return (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> length : 0); }
  343.  
  344.     void SetPackageName();
  345.     wchar_t *PackageName()
  346.     {
  347.         if (! package_name)
  348.             SetPackageName();
  349.         return package_name;
  350.     }
  351.     int PackageNameLength()
  352.     {
  353.         if (! package_name)
  354.             SetPackageName();
  355.         return package_name_length;
  356.     }
  357.  
  358.     inline PackageSymbol *FindPackageSymbol(NameSymbol *);
  359.     inline PackageSymbol *InsertPackageSymbol(NameSymbol *);
  360.  
  361.     inline TypeSymbol *FindTypeSymbol(NameSymbol *);
  362.     inline TypeSymbol *InsertSystemTypeSymbol(NameSymbol *);
  363.     inline TypeSymbol *InsertOuterTypeSymbol(NameSymbol *);
  364.     inline void DeleteTypeSymbol(TypeSymbol *);
  365.  
  366. private:
  367.  
  368.     NameSymbol *name_symbol;
  369.     SymbolTable *table;
  370.     inline SymbolTable *Table();
  371.  
  372.     wchar_t *package_name;
  373.     int package_name_length;
  374. };
  375.  
  376.  
  377. class MethodSymbol : public Symbol, public AccessFlags
  378. { 
  379. public:
  380.     Ast *method_or_constructor_declaration; // AstMethodDeclaration or AstConstructorDeclaration
  381.     NameSymbol *name_symbol;
  382.     TypeSymbol *containing_type;
  383.     BlockSymbol *block_symbol;
  384.     MethodSymbol *next_method;
  385.     Utf8LiteralValue *signature;
  386.  
  387.     //
  388.     // If this method is a method that is generated in order to process initializer
  389.     // blocks contained in the body of a class, it needs to know the set of
  390.     // constructors that might invoke it in order to figure out which exceptions
  391.     // can be safely thrown within an initializer block.
  392.     //
  393.     int NumInitializerConstructors()
  394.     {
  395.         return (initializer_constructors ? initializer_constructors -> Length() : 0);
  396.     }
  397.     MethodSymbol *InitializerConstructor(int i)
  398.     {
  399.         return (*initializer_constructors)[i];
  400.     }
  401.     void AddInitializerConstructor(MethodSymbol *method)
  402.     {
  403.         if (! initializer_constructors)
  404.             initializer_constructors = new Tuple<MethodSymbol *>(8);
  405.         initializer_constructors -> Next() = method;
  406.     }
  407.  
  408.     int max_block_depth,
  409.         constant_pool_index,
  410.         constant_pool_class;
  411.  
  412.     //
  413.     // If the method in question is a private member, we may need to construct
  414.     // another method that allows it to be accessed by inner classes. 
  415.     //
  416.     MethodSymbol *read_method;
  417.  
  418.     //
  419.     // If this method is a method that permits access to a private member of an
  420.     // enclosing type then accessed_member identifies the member in question.
  421.     //
  422.     Symbol *accessed_member;
  423.  
  424.     virtual wchar_t *Name() { return name_symbol -> Name(); }
  425.     virtual int NameLength() { return name_symbol -> NameLength(); }
  426.     virtual NameSymbol *Identity() { return name_symbol; }
  427.     char *Utf8Name() { return (char *) (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> value : NULL); }
  428.     int Utf8NameLength() { return (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> length : 0); }
  429.  
  430.     MethodSymbol(NameSymbol *name_symbol_) : method_or_constructor_declaration(NULL),
  431.                                              name_symbol(name_symbol_),
  432.                                              external_name_symbol(NULL),
  433.                                              containing_type(NULL),
  434.                                              block_symbol(NULL),
  435.                                              next_method(NULL),
  436.                                              signature(NULL),
  437.                                              type_(NULL),
  438.                                              status(0),
  439.                                              header(NULL),
  440.                                              max_block_depth(1), // there must be at least one block in a method
  441.                                                                  // this default is useful for default constructors.
  442.                                              constant_pool_index(0),
  443.                                              constant_pool_class(0),
  444.                                              local_constructor(NULL),
  445.                                              read_method(NULL),
  446.                                              accessed_member(NULL),
  447.                                              formal_parameters(NULL),
  448.                                              throws(NULL),
  449.                                              throws_signatures(NULL),
  450.                                              initializer_constructors(NULL)
  451.     {
  452.         Symbol::_kind = METHOD;
  453.     }
  454.  
  455.     virtual ~MethodSymbol();
  456.  
  457.     bool IsFinal();
  458.  
  459.     bool IsTyped()
  460.     {
  461.         return type_ != NULL;
  462.     }
  463.  
  464.     void SetType(TypeSymbol *_type)
  465.     {
  466.         type_ = _type;
  467.     }
  468.  
  469.     void ProcessMethodSignature(Semantic *, LexStream::TokenIndex);
  470.     void ProcessMethodThrows(Semantic *, LexStream::TokenIndex);
  471.  
  472.     TypeSymbol *Type(Semantic *sem = NULL, LexStream::TokenIndex tok = 0)
  473.     {
  474.         if (! type_)
  475.             ProcessMethodSignature(sem, tok);
  476. assert(type_);
  477.         return type_;
  478.     }
  479.  
  480.     int NumFormalParameters(Semantic *sem = NULL, LexStream::TokenIndex tok = 0)
  481.     {
  482.         if (! type_)
  483.             ProcessMethodSignature(sem, tok);
  484. assert(type_);
  485.         return (formal_parameters ? formal_parameters -> Length() : 0);
  486.     }
  487.     VariableSymbol *FormalParameter(int i)
  488.     {
  489.         return (*formal_parameters)[i];
  490.     }
  491.     void AddFormalParameter(VariableSymbol *variable)
  492.     {
  493.         if (! formal_parameters)
  494.             formal_parameters = new Tuple<VariableSymbol *>(8);
  495.         formal_parameters -> Next() = variable;
  496.     }
  497.  
  498.     int NumThrows(Semantic *sem = NULL, LexStream::TokenIndex tok = 0)
  499.     {
  500.         if (throws_signatures)
  501.             ProcessMethodThrows(sem, tok);
  502. assert(! throws_signatures);
  503.         return (throws ? throws -> Length() : 0);
  504.     }
  505.     TypeSymbol *Throws(int i)
  506.     {
  507.         return (*throws)[i];
  508.     }
  509.     void AddThrows(TypeSymbol *exception)
  510.     {
  511.         if (! throws)
  512.             throws = new Tuple<TypeSymbol *>(8);
  513.         throws -> Next() = exception;
  514.     }
  515.  
  516.     int NumThrowsSignatures()
  517.     {
  518.         return (throws_signatures ? throws_signatures -> Length() : 0);
  519.     }
  520.     char *ThrowsSignature(int i)
  521.     {
  522.         return (*throws_signatures)[i];
  523.     }
  524.     void AddThrowsSignature(char *signature_, int length)
  525.     {
  526.         char *signature = new char[length + 1];
  527.         strncpy(signature, signature_, length);
  528.         signature[length] = U_NULL;
  529.  
  530.         if (! throws_signatures)
  531.             throws_signatures = new Tuple<char *>(8);
  532.         throws_signatures -> Next() = signature;
  533.     }
  534.  
  535.     void SetGeneratedLocalConstructor(MethodSymbol *base_method)
  536.     {
  537. assert(! base_method -> local_constructor);
  538.        base_method -> local_constructor = this;
  539.        this -> local_constructor = base_method;
  540.     }
  541.     bool IsGeneratedLocalConstructor() { return ((local_constructor != NULL) && (this -> external_name_symbol == NULL)); }
  542.     MethodSymbol *LocalConstructor()  { return local_constructor; }
  543.  
  544.     void SetExternalIdentity(NameSymbol *external_name_symbol_) { external_name_symbol = external_name_symbol_; }
  545.     NameSymbol *ExternalIdentity()
  546.     {
  547.         return (external_name_symbol ? external_name_symbol : name_symbol);
  548.     }
  549.     wchar_t *ExternalName()
  550.     {
  551.         return (external_name_symbol ? external_name_symbol -> Name() : name_symbol -> Name());
  552.     }
  553.     int ExternalNameLength()
  554.     {
  555.         return (external_name_symbol ? external_name_symbol -> NameLength() : name_symbol -> NameLength());
  556.     }
  557.     char *ExternalUtf8Name()
  558.     {
  559.         return (char *) (external_name_symbol ? external_name_symbol -> Utf8_literal -> value
  560.                                               : (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> value : NULL));
  561.     }
  562.     int ExternalUtf8NameLength()
  563.     {
  564.         return (external_name_symbol ? (external_name_symbol -> Utf8_literal ? external_name_symbol -> Utf8_literal -> length : 0)
  565.                                      : (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> length : 0));
  566.     }
  567.  
  568.     void SetFlags(AccessFlags variable_access) { access_flags = variable_access.access_flags; }
  569.     void SetContainingType(TypeSymbol *containing_type_) { containing_type = containing_type_; }
  570.     void SetBlockSymbol(BlockSymbol *block_symbol_) { block_symbol = block_symbol_; }
  571.     void SetSignature(Control &, VariableSymbol * = NULL);
  572.     void SetSignature(Utf8LiteralValue *signature_) { signature = signature_; }
  573.     char *SignatureString() { return signature -> value; }
  574.     wchar_t *Header(Semantic * = NULL, LexStream::TokenIndex = 0);
  575.  
  576.     void CleanUp();
  577.  
  578.     void MarkSynthetic() { status |= (unsigned char) 0x08; }
  579.     bool IsSynthetic()   { return status & (unsigned char) 0x08; }
  580.  
  581. private:
  582.     NameSymbol *external_name_symbol;
  583.  
  584.     unsigned char status;
  585.     wchar_t *header;
  586.  
  587.     TypeSymbol *type_;
  588.     Tuple<VariableSymbol *> *formal_parameters;
  589.     Tuple<TypeSymbol *> *throws;
  590.     Tuple<char *> *throws_signatures;
  591.     Tuple<MethodSymbol *> *initializer_constructors;
  592.  
  593.     //
  594.     // If the method in question is a constructor of a local type, we may need to construct
  595.     // another constructor that accepts extra local parameters.
  596.     //
  597.     MethodSymbol *local_constructor;
  598.  
  599.     bool ACC_FINAL()
  600.     {
  601. assert(! "use the ACC_FINAL() flag on a method symbol. Use the function IsFinal() instead");
  602.         return false;
  603.     }
  604. };
  605.  
  606.  
  607. class TypeSymbol : public Symbol, public AccessFlags
  608. { 
  609. public:
  610.     SemanticEnvironment *semantic_environment;
  611.     Ast *declaration;  // AstClassDeclaration or AstInterfaceDeclaration
  612.     FileSymbol *file_symbol;
  613.     FileLocation *file_location;
  614.     NameSymbol *name_symbol;
  615.     Symbol *owner;
  616.     TypeSymbol *outermost_type; // An nested class identifies the outer most type that contains it.
  617.                                 // If a class is not nested then it identifies itself as its outer
  618.                                 // most type.
  619.     TypeSymbol *super;
  620.     TypeSymbol *base_type; // indicates the base type (type of elements in the last dimension) of an array
  621.                            // For a normal type base_type is NULL. If base_type is a "bad" type it points
  622.                            // to itsself (this).
  623.     int index,             // The first two variables is used in TypeCycleChecker to determine if this class or interface
  624.                            // forms a cycle in its "extends" or "implements" relationship.
  625.         incremental_index; // This variable is used in TypeCycleChecker to determine which types (files)
  626.                            // need to be recompiled based on the "dependent" relationship.
  627.  
  628.     int NumLocalConstructorCallEnvironments() { return (local_constructor_call_environments ? local_constructor_call_environments -> Length() : 0); }
  629.     SemanticEnvironment *&LocalConstructorCallEnvironment(int i) { return (*local_constructor_call_environments)[i]; }
  630.     void AddLocalConstructorCallEnvironment(SemanticEnvironment *environment)
  631.     {
  632.         if (! local_constructor_call_environments)
  633.             local_constructor_call_environments = new Tuple<SemanticEnvironment *>(8);
  634.         local_constructor_call_environments -> Next() = environment;
  635.     }
  636.  
  637.     int NumPrivateAccessMethods() { return (private_access_methods ? private_access_methods -> Length() : 0); }
  638.     MethodSymbol *&PrivateAccessMethod(int i) { return (*private_access_methods)[i]; }
  639.     void AddPrivateAccessMethod(MethodSymbol *method_symbol)
  640.     {
  641.         if (! private_access_methods)
  642.             private_access_methods = new Tuple<MethodSymbol *>(8);
  643.         private_access_methods -> Next() = method_symbol;
  644.     }
  645.  
  646.     int NumPrivateAccessConstructors() { return (private_access_constructors ? private_access_constructors -> Length() : 0); }
  647.     MethodSymbol *&PrivateAccessConstructor(int i) { return (*private_access_constructors)[i]; }
  648.     void AddPrivateAccessConstructor(MethodSymbol *constructor_symbol)
  649.     {
  650.         if (! private_access_constructors)
  651.             private_access_constructors = new Tuple<MethodSymbol *>(8);
  652.         private_access_constructors -> Next() = constructor_symbol;
  653.     }
  654.  
  655.     int NumConstructorParameters() { return (constructor_parameters ? constructor_parameters -> Length() : 0); }
  656.     VariableSymbol *&ConstructorParameter(int i) { return (*constructor_parameters)[i]; }
  657.     void AddConstructorParameter(VariableSymbol *variable_symbol)
  658.     {
  659.         if (! constructor_parameters)
  660.             constructor_parameters = new Tuple<VariableSymbol *>(8);
  661.         constructor_parameters -> Next() = variable_symbol;
  662.     }
  663.  
  664.     int NumGeneratedConstructors() { return (generated_constructors ? generated_constructors -> Length() : 0); }
  665.     MethodSymbol *&GeneratedConstructor(int i) { return (*generated_constructors)[i]; }
  666.     void AddGeneratedConstructor(MethodSymbol *constructor_symbol)
  667.     {
  668.         if (! generated_constructors)
  669.             generated_constructors = new Tuple<MethodSymbol *>(8);
  670.         generated_constructors -> Next() = constructor_symbol;
  671.     }
  672.  
  673.     int NumEnclosingInstances() { return (enclosing_instances ? enclosing_instances -> Length() : 0); }
  674.     VariableSymbol *&EnclosingInstance(int i) { return (*enclosing_instances)[i]; }
  675.     void AddEnclosingInstance(VariableSymbol *instance_symbol)
  676.     {
  677.         if (! enclosing_instances)
  678.             enclosing_instances = new Tuple<VariableSymbol *>(8);
  679.         enclosing_instances -> Next() = instance_symbol;
  680.     }
  681.  
  682.     int NumClassLiterals() { return (class_literals ? class_literals -> Length() : 0); }
  683.     VariableSymbol *&ClassLiteral(int i) { return (*class_literals)[i]; }
  684.     void AddClassLiteral(VariableSymbol *literal_symbol)
  685.     {
  686.         if (! class_literals)
  687.             class_literals = new Tuple<VariableSymbol *>(8);
  688.         class_literals -> Next() = literal_symbol;
  689.     }
  690.  
  691.     int NumNestedTypes() { return (nested_types ? nested_types -> Length() : 0); }
  692.     TypeSymbol *&NestedType(int i) { return (*nested_types)[i]; }
  693.     void AddNestedType(TypeSymbol *type_symbol)
  694.     {
  695.         if (! nested_types)
  696.             nested_types = new Tuple<TypeSymbol *>(8);
  697.         nested_types -> Next() = type_symbol;
  698.     }
  699.  
  700.     int NumInterfaces() { return (interfaces ? interfaces -> Length() : 0); }
  701.     void ResetInterfaces()
  702.     {
  703.         delete interfaces;
  704.         interfaces = NULL;
  705.     }
  706.     TypeSymbol *Interface(int i) { return (*interfaces)[i]; }
  707.     void AddInterface(TypeSymbol *type_symbol)
  708.     {
  709.         if (! interfaces)
  710.             interfaces = new Tuple<TypeSymbol *>(8);
  711.         interfaces -> Next() = type_symbol;
  712.     }
  713.  
  714.     int num_anonymous_types() { return (anonymous_types ? anonymous_types -> Length() : 0); }
  715.     TypeSymbol *&AnonymousType(int i) { return (*anonymous_types)[i]; }
  716.     void AddAnonymousType(TypeSymbol *type_symbol)
  717.     {
  718.         if (! anonymous_types)
  719.             anonymous_types = new Tuple<TypeSymbol *>(8);
  720.         anonymous_types -> Next() = type_symbol;
  721.     }
  722.     void DeleteAnonymousTypes();
  723.  
  724.     SymbolSet *local,
  725.               *non_local;
  726.  
  727.     SymbolSet *supertypes_closure,
  728.               *subtypes,
  729.               *subtypes_closure,
  730.               *innertypes_closure;
  731.  
  732.     SymbolSet *dependents,
  733.               *parents,
  734.               *dependents_closure,  // processed in cycle.cpp
  735.               *parents_closure;     // processed in cycle.cpp
  736.  
  737.     int pool_index; // index of element in symbol_pool (in the relevant symbol table) that points to this type
  738.  
  739.     Utf8LiteralValue *signature;
  740.     Utf8LiteralValue *fully_qualified_name;
  741.  
  742.     ExpandedTypeTable *expanded_type_table;
  743.     ExpandedFieldTable *expanded_field_table;
  744.     ExpandedMethodTable *expanded_method_table;
  745.  
  746.     int num_dimensions;
  747.  
  748.     MethodSymbol *static_initializer_method;
  749.     MethodSymbol *block_initializer_method;
  750.  
  751.     virtual wchar_t *Name() { return name_symbol -> Name(); }
  752.     virtual int NameLength() { return name_symbol -> NameLength(); }
  753.     virtual NameSymbol *Identity() { return name_symbol; }
  754.     char *Utf8Name() { return (char *) (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> value : NULL); }
  755.     int Utf8NameLength() { return (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> length : 0); }
  756.  
  757.     void SetExternalIdentity(NameSymbol *external_name_symbol_) { external_name_symbol = external_name_symbol_; }
  758.     NameSymbol *ExternalIdentity()
  759.     {
  760.         return (external_name_symbol ? external_name_symbol : name_symbol);
  761.     }
  762.     wchar_t *ExternalName()
  763.     {
  764.         return (external_name_symbol ? external_name_symbol -> Name() : name_symbol -> Name());
  765.     }
  766.     int ExternalNameLength()
  767.     {
  768.         return (external_name_symbol ? external_name_symbol -> NameLength() : name_symbol -> NameLength());
  769.     }
  770.     char *ExternalUtf8Name()
  771.     {
  772.         return (char *) (external_name_symbol ? external_name_symbol -> Utf8_literal -> value
  773.                                               : (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> value : NULL));
  774.     }
  775.     int ExternalUtf8NameLength()
  776.     {
  777.         return (external_name_symbol ? (external_name_symbol -> Utf8_literal ? external_name_symbol -> Utf8_literal -> length : 0)
  778.                                      : (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> length : 0));
  779.     }
  780.  
  781.     TypeSymbol(NameSymbol *);
  782.     virtual ~TypeSymbol();
  783.  
  784.     void ProcessTypeHeaders();
  785.     void ProcessMembers();
  786.     void CompleteSymbolTable();
  787.     void ProcessExecutableBodies();
  788.     void RemoveCompilationReferences();
  789.  
  790.     NameSymbol *GetThisName(Control &, int);
  791.  
  792.     VariableSymbol *FindThis(int k)
  793.     {
  794. assert(IsInner());
  795. assert(NumConstructorParameters() > 0);
  796.         return (k == 0 ? ConstructorParameter(0)
  797.                        : (VariableSymbol *) (NumEnclosingInstances() > k ? EnclosingInstance(k) : NULL));
  798.     }
  799.     VariableSymbol *InsertThis(int k);
  800.  
  801.     TypeSymbol *FindOrInsertClassLiteralClass(LexStream::TokenIndex);
  802.     TypeSymbol *ClassLiteralClass()
  803.     {
  804.         return class_literal_class;
  805.     }
  806.     MethodSymbol *FindOrInsertClassLiteralMethod(Control &);
  807.     MethodSymbol *ClassLiteralMethod()
  808.     {
  809.         return class_literal_method;
  810.     }
  811.     Utf8LiteralValue *FindOrInsertClassLiteralName(Control &);
  812.     Utf8LiteralValue *ClassLiteralName()
  813.     {
  814.         return class_literal_name;
  815.     }
  816.     VariableSymbol *FindOrInsertClassLiteral(TypeSymbol *);
  817.     VariableSymbol *FindOrInsertLocalShadow(VariableSymbol *);
  818.  
  819.     static MethodSymbol *GetReadAccessMethod(MethodSymbol *);
  820.     static MethodSymbol *GetReadAccessMethod(VariableSymbol *);
  821.     static MethodSymbol *GetWriteAccessMethod(VariableSymbol *);
  822.  
  823.     bool IsArray() { return (num_dimensions > 0); }
  824.  
  825.     void SetOwner(Symbol *owner_) { owner = owner_; }
  826.     bool IsOwner(TypeSymbol *type)
  827.     {
  828.         Symbol *sym = type -> owner;
  829.         while (! sym -> PackageCast())
  830.         {
  831.             if (sym == this)
  832.                 return true;
  833.  
  834.             MethodSymbol *method = sym -> MethodCast();
  835.             sym = (method ? method -> containing_type : ((TypeSymbol *) sym) -> owner);
  836.         }
  837.  
  838.         return false;
  839.     }
  840.  
  841.     TypeSymbol *ContainingType()
  842.     {
  843.         if (owner)
  844.         {
  845.             TypeSymbol *type = owner -> TypeCast();
  846.             if (type)
  847.                 return type;
  848.             MethodSymbol *method = owner -> MethodCast();
  849.             if (method)
  850.                 return method -> containing_type;
  851.         }
  852.  
  853.         return NULL;
  854.     }
  855.  
  856.     bool CanAccess(TypeSymbol *);
  857.  
  858.     bool HasProtectedAccessTo(TypeSymbol *);
  859.  
  860.     bool IsSubclass(TypeSymbol *super_class)
  861.     {
  862.         return (this == super_class ? true : (super == NULL ? false : super -> IsSubclass(super_class)));
  863.     }
  864.  
  865.     bool IsSubinterface(TypeSymbol *super_interface)
  866.     {
  867.         if (this == super_interface)
  868.             return true;
  869.         for (int i = 0; i < NumInterfaces(); i++)
  870.         {
  871.             if (Interface(i) -> IsSubinterface(super_interface))
  872.                 return true;
  873.         }
  874.         return false;
  875.     }
  876.  
  877.     bool Implements(TypeSymbol *inter)
  878.     {
  879.         for (int i = 0; i < NumInterfaces(); i++)
  880.         {
  881.             if (Interface(i) -> IsSubinterface(inter))
  882.                 return true;
  883.         }
  884.         return (this -> super ? this -> super -> Implements(inter) : false);
  885.     }
  886.  
  887.     wchar_t *FileLoc()
  888.     {
  889.         return (wchar_t *) (file_location ? file_location -> location : NULL);
  890.     }
  891.  
  892.     void SetLocation();
  893.  
  894.     TypeSymbol *GetArrayType(Semantic *, int);
  895.  
  896.     TypeSymbol *ArraySubtype()
  897.     {
  898.         return this -> base_type -> Array(this -> num_dimensions - 1);
  899.     }
  900.  
  901.     void SetSignature(Control &);
  902.     void SetSignature(Utf8LiteralValue *signature_) { signature = signature_; }
  903.     char *SignatureString() { return signature -> value; }
  904.  
  905.     void SetClassLiteralName(Utf8LiteralValue *class_literal_name_) { class_literal_name = class_literal_name_; }
  906.  
  907.     PackageSymbol *ContainingPackage() { return outermost_type -> owner -> PackageCast(); }
  908.  
  909.     void SetFlags(AccessFlags variable_access) { access_flags = variable_access.access_flags; }
  910.  
  911.     bool IsNestedIn(TypeSymbol *);
  912.  
  913.     bool IsNested() { return outermost_type != this; }
  914.  
  915.     bool IsTopLevel() { return (! IsNested()) || this -> ACC_STATIC(); }
  916.  
  917.     bool IsInner() { return (! IsTopLevel()); }
  918.  
  919.     bool IsLocal()
  920.     {
  921.         for (Symbol *sym = owner; ! sym -> PackageCast(); sym = ((TypeSymbol *) sym) -> owner)
  922.         {
  923.             if (sym -> MethodCast())
  924.                 return true;
  925.         }
  926.  
  927.         return false;
  928.     }
  929.  
  930.     inline char *ClassName()
  931.     {
  932.         if (! class_name)
  933.             SetClassName();
  934.         return class_name;
  935.     }
  936.  
  937.     void MarkConstructorMembersProcessed() { status |= (unsigned short) 0x0001; }
  938.     bool ConstructorMembersProcessed() { return status & (unsigned short) 0x0001; }
  939.  
  940.     void MarkMethodMembersProcessed() { status |= (unsigned short) 0x0002; }
  941.     bool MethodMembersProcessed() { return status & (unsigned short) 0x0002; }
  942.  
  943.     void MarkFieldMembersProcessed() { status |= (unsigned short) 0x0004; }
  944.     bool FieldMembersProcessed() { return status & (unsigned short) 0x0004; }
  945.  
  946.     void MarkLocalClassProcessingCompleted() { status |= (unsigned short) 0x0008; }
  947.     bool LocalClassProcessingCompleted() { return status & (unsigned short) 0x0008; }
  948.  
  949.     void MarkSourcePending() { status |= (unsigned short) 0x0010; }
  950.     void MarkSourceNoLongerPending() { status &= (~ ((unsigned short) 0x0010)); }
  951.     bool SourcePending() { return status & (unsigned short) 0x0010; }
  952.  
  953.     void MarkAnonymous() { status |= (unsigned short) 0x0020; }
  954.     bool Anonymous() { return status & (unsigned short) 0x0020; }
  955.  
  956.     void MarkHeaderProcessed() { status |= (unsigned short) 0x0040; }
  957.     bool HeaderProcessed() { return status & (unsigned short) 0x0040; }
  958.  
  959.     void MarkPrimitive() { status |= (unsigned short) 0x0080; }
  960.     bool Primitive()     { return status & (unsigned short) 0x0080; }
  961.  
  962.     void MarkBad()
  963.     {
  964.         SetACC_PUBLIC();
  965.  
  966.         status |= (unsigned short) 0x0100;
  967.  
  968.         MarkHeaderProcessed();
  969.         MarkConstructorMembersProcessed();
  970.         MarkMethodMembersProcessed();
  971.         MarkFieldMembersProcessed();
  972.         MarkLocalClassProcessingCompleted();
  973.         MarkSourceNoLongerPending();
  974.  
  975.         return;
  976.     }
  977.     bool Bad() { return status & (unsigned short) 0x0100; }
  978.  
  979.     void MarkCircular()
  980.     {
  981.         status |= (unsigned short) 0x0200;
  982.         MarkBad();
  983.         return;
  984.     }
  985.     void MarkNonCircular() { status &= (~ ((unsigned short) 0x0200)); }
  986.     bool Circular() { return status & (unsigned short) 0x0200; }
  987.  
  988.     void ProcessNestedTypeSignatures(Semantic *, LexStream::TokenIndex);
  989.  
  990.     bool NestedTypesProcessed() { return nested_type_signatures == NULL; }
  991.  
  992.     int NumNestedTypeSignatures()
  993.     {
  994.         return (nested_type_signatures ? nested_type_signatures -> Length() : 0);
  995.     }
  996.     char *NestedTypeSignature(int i)
  997.     {
  998.         return (*nested_type_signatures)[i];
  999.     }
  1000.     void AddNestedTypeSignature(char *signature_, int length)
  1001.     {
  1002.         char *signature = new char[length + 1];
  1003.         strncpy(signature, signature_, length);
  1004.         signature[length] = U_NULL;
  1005.  
  1006.         if (! nested_type_signatures)
  1007.             nested_type_signatures = new Tuple<char *>(8);
  1008.         nested_type_signatures -> Next() = signature;
  1009.     }
  1010.  
  1011.     inline void SetSymbolTable(int);
  1012.     inline SymbolTable *Table();
  1013.  
  1014.     int NumVariableSymbols();
  1015.     VariableSymbol *VariableSym(int);
  1016.  
  1017.     int NumMethodSymbols();
  1018.     MethodSymbol *MethodSym(int);
  1019.  
  1020.     int NumTypeSymbols();
  1021.     TypeSymbol *TypeSym(int);
  1022.  
  1023.     inline TypeSymbol *InsertAnonymousTypeSymbol(NameSymbol *);
  1024.     inline TypeSymbol *FindTypeSymbol(NameSymbol *);
  1025.     inline TypeSymbol *InsertNestedTypeSymbol(NameSymbol *);
  1026.     inline MethodSymbol *FindConstructorSymbol();
  1027.     inline MethodSymbol *InsertConstructorSymbol(NameSymbol *);
  1028.     inline void InsertConstructorSymbol(MethodSymbol *);
  1029.     inline MethodSymbol *FindMethodSymbol(NameSymbol *);
  1030.     inline VariableSymbol *FindVariableSymbol(NameSymbol *);
  1031.     inline VariableSymbol *InsertVariableSymbol(NameSymbol *);
  1032.     inline void InsertVariableSymbol(VariableSymbol *);
  1033.  
  1034.     inline MethodSymbol *InsertMethodSymbol(NameSymbol *);
  1035.     inline void InsertMethodSymbol(MethodSymbol *);
  1036.     inline MethodSymbol *Overload(MethodSymbol *);
  1037.     inline void Overload(MethodSymbol *, MethodSymbol *);
  1038.     inline MethodSymbol *LocalConstructorOverload(MethodSymbol *);
  1039.     MethodSymbol *FindOverloadMethod(MethodSymbol *, AstMethodDeclarator *);
  1040.  
  1041.     inline void CompressSpace();
  1042.  
  1043. private:
  1044.     NameSymbol *external_name_symbol;
  1045.  
  1046.     SymbolTable *table;
  1047.  
  1048.     unsigned short status;
  1049.  
  1050.     PackageSymbol *package;
  1051.     char *class_name;
  1052.  
  1053.     void SetClassName();
  1054.  
  1055.     TypeSymbol *class_literal_class;
  1056.     MethodSymbol *class_literal_method;
  1057.     Utf8LiteralValue *class_literal_name;
  1058.  
  1059.     //
  1060.     // For a local type, when we first encounter an embedded call
  1061.     // to one of its constructors or a constructor of one of its inner
  1062.     // types, either via a ClassInstanceCreation or an ExplicitConstructorInvocation,
  1063.     // we record it and resolve it after we have computed all necessary 
  1064.     // information about the type and its inner types.
  1065.     //
  1066.     Tuple<SemanticEnvironment *> *local_constructor_call_environments;
  1067.  
  1068.     //
  1069.     // When an inner class tries to access a private member of one of its enclosing
  1070.     // classes, one (or two) access method(s) to read (and/or write) the private member
  1071.     // is (are) generated.
  1072.     //
  1073.     Tuple<MethodSymbol *> *private_access_methods;
  1074.     Tuple<MethodSymbol *> *private_access_constructors;
  1075.  
  1076.     //
  1077.     // For an accessible inner class the first elememt in this array
  1078.     // identifies the "this$0" pointer of the containing type. For a local
  1079.     // class, in addition to the this$0 pointer (if it is needed), all local
  1080.     // variables that are referred to in the local type are passed as argument
  1081.     // to the local type and copied in the constructor into a local field. These
  1082.     // local variables are stored in constructor_parameters.
  1083.     //
  1084.     // The array enclosing_instances is there for optimization purposes.
  1085.     // If this type is deeply nested within several other types and it makes
  1086.     // references to members in the enclosing types, then it might
  1087.     // be useful to keep a reference to each of these enclosing
  1088.     // instances in the form of this$0, this$1, this$2, ...
  1089.     //
  1090.     // The array class_identities is used to store static variables of type Class
  1091.     // that contain the proper value for a given type.
  1092.     //
  1093.     Tuple<VariableSymbol *> *constructor_parameters;
  1094.     Tuple<MethodSymbol *> *generated_constructors;
  1095.     Tuple<VariableSymbol *> *enclosing_instances;
  1096.     Tuple<VariableSymbol *> *class_literals;
  1097.  
  1098.     Tuple<char *> *nested_type_signatures;
  1099.  
  1100.     //
  1101.     // The inner types that appear immediately within this type in the order
  1102.     // in which they should be processed (compiled).
  1103.     Tuple<TypeSymbol *> *nested_types;
  1104.  
  1105.     //
  1106.     // The interfaces that were declared in the header of the type.
  1107.     //
  1108.     Tuple<TypeSymbol *> *interfaces;
  1109.  
  1110.     //
  1111.     // The anonymous types that were declared in this type.
  1112.     //
  1113.     Tuple<TypeSymbol *> *anonymous_types;
  1114.  
  1115.     //
  1116.     // The arrays of this type that were declared.
  1117.     //
  1118.     Tuple<TypeSymbol *> *array;
  1119.     inline int NumArrays()
  1120.     {
  1121.         return (array ? array -> Length() : 0);
  1122.     }
  1123.     inline TypeSymbol *Array(int i)
  1124.     {
  1125.         return (*array)[i];
  1126.     }
  1127.     inline void AddArrayType(TypeSymbol *type_symbol)
  1128.     {
  1129.         if (! array)
  1130.             array = new Tuple<TypeSymbol *>(4);
  1131.         array -> Next() = type_symbol;
  1132.     }    
  1133. };
  1134.  
  1135.  
  1136. class VariableSymbol : public Symbol, public AccessFlags
  1137. { 
  1138. public:
  1139.     Ast *declarator;
  1140.  
  1141.     NameSymbol *name_symbol;
  1142.     Symbol     *owner;
  1143.     LiteralValue *initial_value;
  1144.     int constant_pool_index,
  1145.         constant_pool_class,
  1146.         local_program_counter;
  1147.  
  1148.     VariableSymbol *accessed_local;
  1149.     MethodSymbol *read_method,
  1150.                  *write_method;
  1151.  
  1152.     virtual wchar_t *Name() { return name_symbol -> Name(); }
  1153.     virtual int NameLength() { return name_symbol -> NameLength(); }
  1154.     virtual NameSymbol *Identity() { return name_symbol; }
  1155.     char *Utf8Name() { return (char *) (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> value : NULL); }
  1156.     int Utf8NameLength() { return (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> length : 0); }
  1157.  
  1158.     void SetExternalIdentity(NameSymbol *external_name_symbol_) { external_name_symbol = external_name_symbol_; }
  1159.     NameSymbol *ExternalIdentity()
  1160.     {
  1161.         return (external_name_symbol ? external_name_symbol : name_symbol);
  1162.     }
  1163.     wchar_t *ExternalName()
  1164.     {
  1165.         return (external_name_symbol ? external_name_symbol -> Name() : name_symbol -> Name());
  1166.     }
  1167.     int ExternalNameLength()
  1168.     {
  1169.         return (external_name_symbol ? external_name_symbol -> NameLength() : name_symbol -> NameLength());
  1170.     }
  1171.     char *ExternalUtf8Name()
  1172.     {
  1173.         return (char *) (external_name_symbol ? external_name_symbol -> Utf8_literal -> value
  1174.                                               : (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> value : NULL));
  1175.     }
  1176.     int ExternalUtf8NameLength()
  1177.     {
  1178.         return (external_name_symbol ? (external_name_symbol -> Utf8_literal ? external_name_symbol -> Utf8_literal -> length : 0)
  1179.                                      : (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> length : 0));
  1180.     }
  1181.  
  1182.     VariableSymbol(NameSymbol *name_symbol_) : declarator(NULL),
  1183.                                                name_symbol(name_symbol_),
  1184.                                                external_name_symbol(NULL),
  1185.                                                owner(NULL),
  1186.                                                type_(NULL),
  1187.                                                signature_string(NULL),
  1188.                                                initial_value(NULL),
  1189.                                                local_variable_index_(-1), 
  1190.                                                constant_pool_index(0),
  1191.                                                constant_pool_class(0),
  1192.                                                local_program_counter(0),
  1193.                                                accessed_local(NULL),
  1194.                                                read_method(NULL),
  1195.                                                write_method(NULL),
  1196.                                                status(0)
  1197.     {
  1198.         Symbol::_kind = VARIABLE;
  1199.     }
  1200.  
  1201.     virtual ~VariableSymbol() { delete [] signature_string; }
  1202.  
  1203.     void SetFlags(AccessFlags variable_access) { access_flags = variable_access.access_flags; }
  1204.     void SetOwner(Symbol *owner_) { owner = owner_; }
  1205.  
  1206.     void SetLocalVariableIndex(int index)
  1207.     {
  1208.         local_variable_index_ = index;
  1209.         MarkComplete();
  1210.     }
  1211.     int LocalVariableIndex() { return local_variable_index_; }
  1212.  
  1213.     bool IsTyped()
  1214.     {
  1215.         return type_ != NULL;
  1216.     }
  1217.  
  1218.     void SetType(TypeSymbol *_type)
  1219.     {
  1220.         type_ = _type;
  1221.     }
  1222.  
  1223.     void ProcessVariableSignature(Semantic *, LexStream::TokenIndex);
  1224.  
  1225.     TypeSymbol *Type(Semantic *sem = NULL, LexStream::TokenIndex tok = 0)
  1226.     {
  1227.         if (! type_)
  1228.             ProcessVariableSignature(sem, tok);
  1229. assert(type_);
  1230.         return type_;
  1231.     }
  1232.  
  1233.     void SetSignatureString(char *signature_, int length)
  1234.     {
  1235.         signature_string = new char[length + 1];
  1236.         strncpy(signature_string, signature_, length);
  1237.         signature_string[length] = U_NULL;
  1238.     }
  1239.  
  1240.     bool IsLocal()                     { return owner -> MethodCast() != NULL; }           // is variable a local variable?
  1241.     bool IsLocal(MethodSymbol *method) { return owner == method; } // is variable local to a particular method ?
  1242.     bool IsFinal(TypeSymbol *type)     { return (owner == type && ACC_FINAL()); }
  1243.  
  1244.     //
  1245.     // These functions are used to identify when the declaration of a field in the body of a class is
  1246.     // complete.
  1247.     //
  1248.     void MarkIncomplete()         { status &= (~((unsigned char) 0x01)); }
  1249.     void MarkComplete()           { status |= (unsigned char) 0x01; }
  1250.     bool IsDeclarationComplete()  { return status & (unsigned char) 0x01; }
  1251.  
  1252.     void MarkNotDefinitelyAssigned() { status &= (~((unsigned char) 0x02)); }
  1253.     void MarkDefinitelyAssigned()    { status |= (unsigned char) 0x02; }
  1254.     bool IsDefinitelyAssigned()      { return status & (unsigned char) 0x02; }
  1255.  
  1256.     void MarkPossiblyAssigned() { status |= (unsigned char) 0x04; }
  1257.     bool IsPossiblyAssigned()   { return status & (unsigned char) 0x04; }
  1258.  
  1259.     void MarkSynthetic() { status |= (unsigned char) 0x08; }
  1260.     bool IsSynthetic()   { return status & (unsigned char) 0x08; }
  1261.  
  1262. private:
  1263.     NameSymbol *external_name_symbol;
  1264.  
  1265.     unsigned char status;
  1266.     int local_variable_index_;
  1267.     TypeSymbol *type_;
  1268.     char *signature_string;
  1269. };
  1270.  
  1271.  
  1272. class BlockSymbol : public Symbol
  1273. { 
  1274. public:
  1275.     int max_variable_index,
  1276.         synchronized_variable_index,
  1277.         try_variable_index;
  1278.  
  1279.     BlockSymbol(int hash_size);
  1280.     virtual ~BlockSymbol();
  1281.  
  1282.     int NumVariableSymbols();
  1283.     VariableSymbol *VariableSym(int);
  1284.  
  1285.     inline VariableSymbol *FindVariableSymbol(NameSymbol *);
  1286.     inline VariableSymbol *InsertVariableSymbol(NameSymbol *);
  1287.     inline void InsertVariableSymbol(VariableSymbol *);
  1288.     inline BlockSymbol *InsertBlockSymbol(int);
  1289.  
  1290.     inline void CompressSpace();
  1291.  
  1292.     inline SymbolTable *Table();
  1293.  
  1294. private:
  1295.  
  1296.     SymbolTable *table;
  1297. };
  1298.  
  1299.  
  1300. class LabelSymbol : public Symbol
  1301. { 
  1302. public:
  1303.     AstBlock *block; // the block that is labeled by this symbol
  1304.     NameSymbol *name_symbol;
  1305.  
  1306.     int nesting_level;
  1307.  
  1308.     virtual wchar_t *Name() { return name_symbol -> Name(); }
  1309.     virtual int NameLength() { return name_symbol -> NameLength(); }
  1310.     virtual NameSymbol *Identity() { return name_symbol; }
  1311.     char *Utf8Name() { return (char *) (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> value : NULL); }
  1312.     int Utf8NameLength() { return (name_symbol -> Utf8_literal ? name_symbol -> Utf8_literal -> length : 0); }
  1313.  
  1314.     LabelSymbol(NameSymbol *name_symbol_) : block(NULL),
  1315.                                             nesting_level(0),
  1316.                                             name_symbol(name_symbol_)
  1317.     {
  1318.         Symbol::_kind = LABEL;
  1319.     }
  1320.  
  1321.     virtual ~LabelSymbol() {}
  1322.  
  1323. private:
  1324. };
  1325.  
  1326.  
  1327. class SymbolTable
  1328. {
  1329. public:
  1330.     enum
  1331.     {
  1332.         DEFAULT_HASH_SIZE = 13,
  1333.         MAX_HASH_SIZE = 1021
  1334.     };
  1335.  
  1336.     int NumAnonymousSymbols()
  1337.     {
  1338.         return (anonymous_symbol_pool ? anonymous_symbol_pool -> Length() : 0);
  1339.     }
  1340.     TypeSymbol *AnonymousSym(int i)
  1341.     {
  1342.         return (*anonymous_symbol_pool)[i];
  1343.     }
  1344.     void AddAnonymousSymbol(TypeSymbol *symbol)
  1345.     {
  1346.         if (! anonymous_symbol_pool)
  1347.             anonymous_symbol_pool = new ConvertibleArray<TypeSymbol *>(256);
  1348.         anonymous_symbol_pool -> Next() = symbol;
  1349.     }
  1350.  
  1351.     int NumTypeSymbols()
  1352.     {
  1353.         return (type_symbol_pool ? type_symbol_pool -> Length() : 0);
  1354.     }
  1355.     TypeSymbol *&TypeSym(int i)
  1356.     {
  1357.         return (*type_symbol_pool)[i];
  1358.     }
  1359.     void AddTypeSymbol(TypeSymbol *symbol)
  1360.     {
  1361.         if (! type_symbol_pool)
  1362.             type_symbol_pool = new ConvertibleArray<TypeSymbol *>(256);
  1363.         type_symbol_pool -> Next() = symbol;
  1364.     }
  1365.  
  1366.     int NumMethodSymbols()
  1367.     {
  1368.         return (method_symbol_pool ? method_symbol_pool -> Length() : 0);
  1369.     }
  1370.     MethodSymbol *MethodSym(int i)
  1371.     {
  1372.         return (*method_symbol_pool)[i];
  1373.     }
  1374.     void AddMethodSymbol(MethodSymbol *symbol)
  1375.     {
  1376.         if (! method_symbol_pool)
  1377.             method_symbol_pool = new ConvertibleArray<MethodSymbol *>(256);
  1378.         method_symbol_pool -> Next() = symbol;
  1379.     }
  1380.  
  1381.     int NumVariableSymbols()
  1382.     {
  1383.         return (variable_symbol_pool ? variable_symbol_pool -> Length() : 0);
  1384.     }
  1385.     VariableSymbol *VariableSym(int i)
  1386.     {
  1387.         return (*variable_symbol_pool)[i];
  1388.     }
  1389.     void AddVariableSymbol(VariableSymbol *symbol)
  1390.     {
  1391.         if (! variable_symbol_pool)
  1392.             variable_symbol_pool = new ConvertibleArray<VariableSymbol *>(256);
  1393.         variable_symbol_pool -> Next() = symbol;
  1394.     }
  1395.  
  1396.     int NumOtherSymbols()
  1397.     {
  1398.         return (other_symbol_pool ? other_symbol_pool -> Length() : 0);
  1399.     }
  1400.     Symbol *OtherSym(int i)
  1401.     {
  1402.         return (*other_symbol_pool)[i];
  1403.     }
  1404.     void AddOtherSymbol(Symbol *symbol)
  1405.     {
  1406.         if (! other_symbol_pool)
  1407.             other_symbol_pool = new ConvertibleArray<Symbol *>(256);
  1408.         other_symbol_pool -> Next() = symbol;
  1409.     }
  1410.  
  1411.     SymbolTable(int hash_size_ = DEFAULT_HASH_SIZE);
  1412.     ~SymbolTable();
  1413.  
  1414.     inline void CompressSpace()
  1415.     {
  1416.         if (anonymous_symbol_pool)
  1417.             (void) anonymous_symbol_pool -> Array();
  1418.         if (method_symbol_pool)
  1419.             (void) method_symbol_pool -> Array();
  1420.         if (variable_symbol_pool)
  1421.             (void) variable_symbol_pool -> Array();
  1422.         if (other_symbol_pool)
  1423.             (void) other_symbol_pool -> Array();
  1424.  
  1425.         return;
  1426.     }
  1427.  
  1428. private:
  1429.  
  1430.     Tuple<TypeSymbol *> *type_symbol_pool; // This array should not be convertible. See SymbolTable::DeleteTypeSymbol
  1431.  
  1432.     ConvertibleArray<TypeSymbol *>     *anonymous_symbol_pool;
  1433.     ConvertibleArray<MethodSymbol *>   *method_symbol_pool;
  1434.     ConvertibleArray<VariableSymbol *> *variable_symbol_pool;
  1435.     ConvertibleArray<Symbol *>         *other_symbol_pool;
  1436.  
  1437.     Symbol **base;
  1438.     int hash_size;
  1439.  
  1440.     static int primes[];
  1441.     int prime_index;
  1442.  
  1443.     int Size()
  1444.     {
  1445.         return NumAnonymousSymbols() +
  1446.                NumTypeSymbols() +
  1447.                NumMethodSymbols() +
  1448.                NumVariableSymbols() +
  1449.                NumOtherSymbols();
  1450.     }
  1451.     void Rehash();
  1452.  
  1453.     MethodSymbol *constructor;
  1454.  
  1455. public:
  1456.  
  1457.     inline PathSymbol *InsertPathSymbol(NameSymbol *, DirectorySymbol *);
  1458.     inline PathSymbol *FindPathSymbol(NameSymbol *);
  1459.     inline DirectorySymbol *InsertDirectorySymbol(NameSymbol *, Symbol *);
  1460.     inline DirectorySymbol *InsertAndReadDirectorySymbol(NameSymbol *, Symbol *);
  1461.     inline DirectorySymbol *FindDirectorySymbol(NameSymbol *);
  1462.     inline FileSymbol *InsertFileSymbol(NameSymbol *);
  1463.     inline FileSymbol *FindFileSymbol(NameSymbol *);
  1464.     inline PackageSymbol *InsertPackageSymbol(NameSymbol *, PackageSymbol *);
  1465.     inline PackageSymbol *FindPackageSymbol(NameSymbol *);
  1466.     inline TypeSymbol *InsertAnonymousTypeSymbol(NameSymbol *);
  1467.     inline TypeSymbol *InsertSystemTypeSymbol(NameSymbol *);
  1468.     inline TypeSymbol *InsertOuterTypeSymbol(NameSymbol *);
  1469.     inline TypeSymbol *InsertNestedTypeSymbol(NameSymbol *);
  1470.     inline void DeleteTypeSymbol(TypeSymbol *);
  1471.     inline void DeleteAnonymousTypes();
  1472.     inline TypeSymbol *FindTypeSymbol(NameSymbol *);
  1473.     inline MethodSymbol *InsertMethodSymbol(NameSymbol *);
  1474.     inline MethodSymbol *InsertConstructorSymbol(NameSymbol *);
  1475.     inline void InsertMethodSymbol(MethodSymbol *);
  1476.     inline void InsertConstructorSymbol(MethodSymbol *);
  1477.     inline MethodSymbol *FindMethodSymbol(NameSymbol *);
  1478.     inline MethodSymbol *FindConstructorSymbol();
  1479.     inline VariableSymbol *InsertVariableSymbol(NameSymbol *);
  1480.     inline void InsertVariableSymbol(VariableSymbol *);
  1481.     inline VariableSymbol *FindVariableSymbol(NameSymbol *);
  1482.     inline LabelSymbol *InsertLabelSymbol(NameSymbol *);
  1483.     inline LabelSymbol *FindLabelSymbol(NameSymbol *);
  1484.     inline BlockSymbol *InsertBlockSymbol(int);
  1485.  
  1486.     inline MethodSymbol *Overload(MethodSymbol *);
  1487.     inline void Overload(MethodSymbol *, MethodSymbol *);
  1488.     inline MethodSymbol *LocalConstructorOverload(MethodSymbol *);
  1489.     MethodSymbol *FindOverloadMethod(MethodSymbol *, AstMethodDeclarator *);
  1490. };
  1491.  
  1492.  
  1493. inline int TypeSymbol::NumVariableSymbols() { return (table ? table -> NumVariableSymbols() : 0); }
  1494. inline int BlockSymbol::NumVariableSymbols() { return (table ? table -> NumVariableSymbols() : 0); }
  1495.  
  1496. inline VariableSymbol *TypeSymbol::VariableSym(int i) { return table -> VariableSym(i); }
  1497. inline VariableSymbol *BlockSymbol::VariableSym(int i) { return table -> VariableSym(i); }
  1498.  
  1499. inline int TypeSymbol::NumMethodSymbols() { return (table ? table -> NumMethodSymbols() : 0); }
  1500.  
  1501. inline MethodSymbol *TypeSymbol::MethodSym(int i) { return table -> MethodSym(i); }
  1502.  
  1503. inline int TypeSymbol::NumTypeSymbols() { return (table ? table -> NumTypeSymbols() : 0); }
  1504.  
  1505. inline TypeSymbol *TypeSymbol::TypeSym(int i) { return table -> TypeSym(i); }
  1506.  
  1507. inline void TypeSymbol::CompressSpace() { if (table) table -> CompressSpace(); }
  1508. inline void BlockSymbol::CompressSpace() { if (table) table -> CompressSpace(); }
  1509.  
  1510. inline PathSymbol *SymbolTable::InsertPathSymbol(NameSymbol *name_symbol, DirectorySymbol *directory_symbol)
  1511. {
  1512. assert(base);
  1513.     PathSymbol *symbol = new PathSymbol(name_symbol);
  1514.     directory_symbol -> owner = symbol;
  1515.     symbol -> root_directory = directory_symbol;
  1516.     AddOtherSymbol(symbol);
  1517.  
  1518.     int k = name_symbol -> index % hash_size;
  1519.     symbol -> next = base[k];
  1520.     base[k] = symbol;
  1521.  
  1522.     //
  1523.     // If the set is "adjustable" and the number of unique elements in it exceeds
  1524.     // 2 times the size of the base, and we have not yet reached the maximum
  1525.     // allowable size for a base, reallocate a larger base and rehash the elements.
  1526.     //
  1527.     if ((hash_size < MAX_HASH_SIZE) && (Size() > (hash_size << 1)))
  1528.         Rehash();
  1529.  
  1530.     return symbol;
  1531. }
  1532.  
  1533.  
  1534. inline PathSymbol *SymbolTable::FindPathSymbol(NameSymbol *name_symbol)
  1535. {
  1536. assert(base);
  1537.     for (Symbol *symbol = base[name_symbol -> index % hash_size]; symbol; symbol = symbol -> next)
  1538.     {
  1539.         if (name_symbol == symbol -> Identity())
  1540.             return (PathSymbol *) symbol;
  1541.     }
  1542.  
  1543.     return (PathSymbol *) NULL;
  1544. }
  1545.  
  1546.  
  1547. inline DirectorySymbol *SymbolTable::InsertDirectorySymbol(NameSymbol *name_symbol, Symbol *owner)
  1548. {
  1549. assert(base);
  1550.     DirectorySymbol *symbol = new DirectorySymbol(name_symbol, owner);
  1551.     AddOtherSymbol(symbol);
  1552.  
  1553.     int k = name_symbol -> index % hash_size;
  1554.     symbol -> next = base[k];
  1555.     base[k] = symbol;
  1556.  
  1557.     //
  1558.     // If the set is "adjustable" and the number of unique elements in it exceeds
  1559.     // 2 times the size of the base, and we have not yet reached the maximum
  1560.     // allowable size for a base, reallocate a larger base and rehash the elements.
  1561.     //
  1562.     if ((hash_size < MAX_HASH_SIZE) && (Size() > (hash_size << 1)))
  1563.         Rehash();
  1564.  
  1565.     return symbol;
  1566. }
  1567.  
  1568.  
  1569. inline DirectorySymbol *SymbolTable::InsertAndReadDirectorySymbol(NameSymbol *name_symbol, Symbol *owner)
  1570. {
  1571.     DirectorySymbol *subdirectory_symbol = InsertDirectorySymbol(name_symbol, owner);
  1572.     subdirectory_symbol -> ResetDirectory();
  1573.  
  1574.     return subdirectory_symbol;
  1575. }
  1576.  
  1577.  
  1578. inline DirectorySymbol *DirectorySymbol::InsertDirectorySymbol(NameSymbol *name_symbol)
  1579. {
  1580.     DirectorySymbol *subdirectory_symbol = Table() -> InsertDirectorySymbol(name_symbol, this);
  1581.     this -> subdirectories.Next() = subdirectory_symbol;
  1582.  
  1583.     return subdirectory_symbol;
  1584. }
  1585.  
  1586.  
  1587. inline DirectorySymbol *DirectorySymbol::InsertAndReadDirectorySymbol(NameSymbol *name_symbol)
  1588. {
  1589.     DirectorySymbol *subdirectory_symbol = Table() -> InsertAndReadDirectorySymbol(name_symbol, this);
  1590.     this -> subdirectories.Next() = subdirectory_symbol;
  1591.  
  1592.     return subdirectory_symbol;
  1593. }
  1594.  
  1595.  
  1596. inline DirectorySymbol *SymbolTable::FindDirectorySymbol(NameSymbol *name_symbol)
  1597. {
  1598. assert(base);
  1599.     for (Symbol *symbol = base[name_symbol -> index % hash_size]; symbol; symbol = symbol -> next)
  1600.     {
  1601.         if (name_symbol == symbol -> Identity())
  1602.         {
  1603.             DirectorySymbol *directory_symbol = symbol -> DirectoryCast();
  1604.             if (directory_symbol)
  1605.                 return directory_symbol;
  1606.         }
  1607.     }
  1608.  
  1609.     return (DirectorySymbol *) NULL;
  1610. }
  1611.  
  1612.  
  1613. inline DirectorySymbol *DirectorySymbol::FindDirectorySymbol(NameSymbol *name_symbol)
  1614. {
  1615.     return (table ? table -> FindDirectorySymbol(name_symbol) : (DirectorySymbol *) NULL);
  1616. }
  1617.  
  1618.  
  1619. inline FileSymbol *SymbolTable::InsertFileSymbol(NameSymbol *name_symbol)
  1620. {
  1621. assert(base);
  1622.     FileSymbol *symbol = new FileSymbol(name_symbol);
  1623.     AddOtherSymbol(symbol);
  1624.  
  1625.     int k = name_symbol -> index % hash_size;
  1626.     symbol -> next = base[k];
  1627.     base[k] = symbol;
  1628.  
  1629.     //
  1630.     // If the set is "adjustable" and the number of unique elements in it exceeds
  1631.     // 2 times the size of the base, and we have not yet reached the maximum
  1632.     // allowable size for a base, reallocate a larger base and rehash the elements.
  1633.     //
  1634.     if ((hash_size < MAX_HASH_SIZE) && (Size() > (hash_size << 1)))
  1635.         Rehash();
  1636.  
  1637.     return symbol;
  1638. }
  1639.  
  1640.  
  1641. inline FileSymbol *DirectorySymbol::InsertFileSymbol(NameSymbol *name_symbol)
  1642. {
  1643.     return Table() -> InsertFileSymbol(name_symbol);
  1644. }
  1645.  
  1646.  
  1647. inline FileSymbol *SymbolTable::FindFileSymbol(NameSymbol *name_symbol)
  1648. {
  1649. assert(base);
  1650.     for (Symbol *symbol = base[name_symbol -> index % hash_size]; symbol; symbol = symbol -> next)
  1651.     {
  1652.         if (name_symbol == symbol -> Identity())
  1653.         {
  1654.             FileSymbol *file_symbol = symbol -> FileCast();
  1655.             if (file_symbol)
  1656.                 return file_symbol;
  1657.         }
  1658.     }
  1659.  
  1660.     return (FileSymbol *) NULL;
  1661. }
  1662.  
  1663.  
  1664. inline FileSymbol *DirectorySymbol::FindFileSymbol(NameSymbol *name_symbol)
  1665. {
  1666.     return (table ? table -> FindFileSymbol(name_symbol) : (FileSymbol *) NULL);
  1667. }
  1668.  
  1669.  
  1670. inline PackageSymbol *SymbolTable::InsertPackageSymbol(NameSymbol *name_symbol, PackageSymbol *owner)
  1671. {
  1672. assert(base);
  1673.     PackageSymbol *symbol = new PackageSymbol(name_symbol, owner);
  1674.     AddOtherSymbol(symbol);
  1675.  
  1676.     int k = name_symbol -> index % hash_size;
  1677.     symbol -> next = base[k];
  1678.     base[k] = symbol;
  1679.  
  1680.     //
  1681.     // If the set is "adjustable" and the number of unique elements in it exceeds
  1682.     // 2 times the size of the base, and we have not yet reached the maximum
  1683.     // allowable size for a base, reallocate a larger base and rehash the elements.
  1684.     //
  1685.     if ((hash_size < MAX_HASH_SIZE) && (Size() > (hash_size << 1)))
  1686.         Rehash();
  1687.  
  1688.     return symbol;
  1689. }
  1690.  
  1691.  
  1692. inline PackageSymbol *PackageSymbol::InsertPackageSymbol(NameSymbol *name_symbol)
  1693. {
  1694.     return Table() -> InsertPackageSymbol(name_symbol, this);
  1695. }
  1696.  
  1697.  
  1698. inline PackageSymbol *SymbolTable::FindPackageSymbol(NameSymbol *name_symbol)
  1699. {
  1700. assert(base);
  1701.     for (Symbol *symbol = base[name_symbol -> index % hash_size]; symbol; symbol = symbol -> next)
  1702.     {
  1703.         if (name_symbol == symbol -> Identity())
  1704.         {
  1705.             PackageSymbol *package_symbol = symbol -> PackageCast();
  1706.             if (package_symbol)
  1707.                 return package_symbol;
  1708.         }
  1709.     }
  1710.  
  1711.     return (PackageSymbol *) NULL;
  1712. }
  1713.  
  1714.  
  1715. inline PackageSymbol *PackageSymbol::FindPackageSymbol(NameSymbol *name_symbol)
  1716. {
  1717.   return (table ? table -> FindPackageSymbol(name_symbol) : (PackageSymbol *) NULL);
  1718. }
  1719.  
  1720. inline TypeSymbol *SymbolTable::InsertAnonymousTypeSymbol(NameSymbol *name_symbol)
  1721. {
  1722.     TypeSymbol *symbol = new TypeSymbol(name_symbol);
  1723.     AddAnonymousSymbol(symbol);
  1724.  
  1725.     return symbol;
  1726. }
  1727.  
  1728.  
  1729. inline TypeSymbol *TypeSymbol::InsertAnonymousTypeSymbol(NameSymbol *name_symbol)
  1730. {
  1731.     return Table() -> InsertAnonymousTypeSymbol(name_symbol);
  1732. }
  1733.  
  1734.  
  1735. inline TypeSymbol *SymbolTable::InsertSystemTypeSymbol(NameSymbol *name_symbol)
  1736. {
  1737. assert(base);
  1738.     TypeSymbol *symbol = new TypeSymbol(name_symbol);
  1739.     symbol -> pool_index = NumTypeSymbols();
  1740.     AddTypeSymbol(symbol);
  1741.  
  1742.     int k = name_symbol -> index % hash_size;
  1743.     symbol -> next = base[k];
  1744.     base[k] = symbol;
  1745.  
  1746.     //
  1747.     // If the set is "adjustable" and the number of unique elements in it exceeds
  1748.     // 2 times the size of the base, and we have not yet reached the maximum
  1749.     // allowable size for a base, reallocate a larger base and rehash the elements.
  1750.     //
  1751.     if ((hash_size < MAX_HASH_SIZE) && (Size() > (hash_size << 1)))
  1752.         Rehash();
  1753.  
  1754.     return symbol;
  1755. }
  1756.  
  1757.  
  1758. inline TypeSymbol *PackageSymbol::InsertSystemTypeSymbol(NameSymbol *name_symbol)
  1759. {
  1760.     return Table() -> InsertSystemTypeSymbol(name_symbol);
  1761. }
  1762.  
  1763.  
  1764. inline TypeSymbol *SymbolTable::InsertOuterTypeSymbol(NameSymbol *name_symbol)
  1765. {
  1766. assert(base);
  1767.     TypeSymbol *symbol = new TypeSymbol(name_symbol);
  1768.     symbol -> pool_index = NumTypeSymbols();
  1769.     AddTypeSymbol(symbol);
  1770.  
  1771.     int k = name_symbol -> index % hash_size;
  1772.     symbol -> next = base[k];
  1773.     base[k] = symbol;
  1774.  
  1775.     //
  1776.     // If the set is "adjustable" and the number of unique elements in it exceeds
  1777.     // 2 times the size of the base, and we have not yet reached the maximum
  1778.     // allowable size for a base, reallocate a larger base and rehash the elements.
  1779.     //
  1780.     if ((hash_size < MAX_HASH_SIZE) && (Size() > (hash_size << 1)))
  1781.         Rehash();
  1782.  
  1783.     return symbol;
  1784. }
  1785.  
  1786.  
  1787. inline TypeSymbol *PackageSymbol::InsertOuterTypeSymbol(NameSymbol *name_symbol)
  1788. {
  1789.     return Table() -> InsertOuterTypeSymbol(name_symbol);
  1790. }
  1791.  
  1792.  
  1793. inline TypeSymbol *SymbolTable::InsertNestedTypeSymbol(NameSymbol *name_symbol)
  1794. {
  1795. assert(base);
  1796.     TypeSymbol *symbol = new TypeSymbol(name_symbol);
  1797.     symbol -> pool_index = NumTypeSymbols();
  1798.     AddTypeSymbol(symbol);
  1799.  
  1800.     int k = name_symbol -> index % hash_size;
  1801.     symbol -> next = base[k];
  1802.     base[k] = symbol;
  1803.  
  1804.     //
  1805.     // If the set is "adjustable" and the number of unique elements in it exceeds
  1806.     // 2 times the size of the base, and we have not yet reached the maximum
  1807.     // allowable size for a base, reallocate a larger base and rehash the elements.
  1808.     //
  1809.     if ((hash_size < MAX_HASH_SIZE) && (Size() > (hash_size << 1)))
  1810.         Rehash();
  1811.  
  1812.     return symbol;
  1813. }
  1814.  
  1815.  
  1816. inline TypeSymbol *TypeSymbol::InsertNestedTypeSymbol(NameSymbol *name_symbol)
  1817. {
  1818.     return Table() -> InsertNestedTypeSymbol(name_symbol);
  1819. }
  1820.  
  1821.  
  1822. inline void SymbolTable::DeleteTypeSymbol(TypeSymbol *type)
  1823. {
  1824. assert(base);
  1825.     int k = type -> name_symbol -> index % hash_size;
  1826.     if (type == base[k])
  1827.         base[k] = type -> next;
  1828.     else
  1829.     {
  1830.         Symbol *previous = base[k];
  1831.         for (Symbol *symbol = previous -> next; symbol != type; previous = symbol, symbol = symbol -> next)
  1832.             ;
  1833.         previous -> next = type -> next;
  1834.     }
  1835.  
  1836.     int last_index = NumTypeSymbols() - 1;
  1837.     if (type -> pool_index != last_index)
  1838.     {// move last element to position previously occupied by element being deleted
  1839.         TypeSym(last_index) -> pool_index = type -> pool_index;
  1840.         TypeSym(type -> pool_index) = TypeSym(last_index);
  1841.     }
  1842.  
  1843.     type_symbol_pool -> Reset(last_index); // remove last slot in symbol_pool
  1844.  
  1845.     delete type;
  1846.  
  1847.     return;
  1848. }
  1849.  
  1850.  
  1851. inline void PackageSymbol::DeleteTypeSymbol(TypeSymbol *type)
  1852. {
  1853.     if (table)
  1854.         table -> DeleteTypeSymbol(type);
  1855. }
  1856.  
  1857.  
  1858. inline void SymbolTable::DeleteAnonymousTypes()
  1859. {
  1860.     for (int i = 0; i < NumAnonymousSymbols(); i++)
  1861.         delete AnonymousSym(i);
  1862.     delete anonymous_symbol_pool;
  1863.     anonymous_symbol_pool = NULL;
  1864.  
  1865.     return;
  1866. }
  1867.  
  1868.  
  1869. inline void TypeSymbol::DeleteAnonymousTypes()
  1870. {
  1871.     delete anonymous_types;
  1872.     anonymous_types = NULL;
  1873.     if (table)
  1874.         table -> DeleteAnonymousTypes();
  1875. }
  1876.  
  1877. inline TypeSymbol *SymbolTable::FindTypeSymbol(NameSymbol *name_symbol)
  1878. {
  1879. assert(base);
  1880.     for (Symbol *symbol = base[name_symbol -> index % hash_size]; symbol; symbol = symbol -> next)
  1881.     {
  1882.         if (name_symbol == symbol -> Identity())
  1883.         {
  1884.             TypeSymbol *type = symbol -> TypeCast();
  1885.             if (type)
  1886.                 return type;
  1887.         }
  1888.     }
  1889.  
  1890.     return (TypeSymbol *) NULL;
  1891. }
  1892.  
  1893.  
  1894. inline TypeSymbol *PackageSymbol::FindTypeSymbol(NameSymbol *name_symbol)
  1895. {
  1896.     return (table ? table -> FindTypeSymbol(name_symbol) : (TypeSymbol *) NULL);
  1897. }
  1898.  
  1899.  
  1900. inline TypeSymbol *TypeSymbol::FindTypeSymbol(NameSymbol *name_symbol)
  1901. {
  1902.     return (table ? table -> FindTypeSymbol(name_symbol) : (TypeSymbol *) NULL);
  1903. }
  1904.  
  1905.  
  1906. inline MethodSymbol *SymbolTable::InsertMethodSymbol(NameSymbol *name_symbol)
  1907. {
  1908. assert(base);
  1909.     MethodSymbol *symbol = new MethodSymbol(name_symbol);
  1910.     AddMethodSymbol(symbol);
  1911.  
  1912.     int k = name_symbol -> index % hash_size;
  1913.     symbol -> next = base[k];
  1914.     base[k] = symbol;
  1915.  
  1916.     //
  1917.     // If the set is "adjustable" and the number of unique elements in it exceeds
  1918.     // 2 times the size of the base, and we have not yet reached the maximum
  1919.     // allowable size for a base, reallocate a larger base and rehash the elements.
  1920.     //
  1921.     if ((hash_size < MAX_HASH_SIZE) && (Size() > (hash_size << 1)))
  1922.         Rehash();
  1923.  
  1924.     return symbol;
  1925. }
  1926.  
  1927.  
  1928. inline MethodSymbol *TypeSymbol::InsertMethodSymbol(NameSymbol *name_symbol)
  1929. {
  1930.     return Table() -> InsertMethodSymbol(name_symbol);
  1931. }
  1932.  
  1933.  
  1934. inline MethodSymbol *SymbolTable::InsertConstructorSymbol(NameSymbol *name_symbol)
  1935. {
  1936. assert(! constructor);
  1937.     this -> constructor = InsertMethodSymbol(name_symbol);
  1938.     return this -> constructor;
  1939. }
  1940.  
  1941.  
  1942. inline MethodSymbol *TypeSymbol::InsertConstructorSymbol(NameSymbol *name_symbol)
  1943. {
  1944.     return Table() -> InsertConstructorSymbol(name_symbol);
  1945. }
  1946.  
  1947.  
  1948. inline void SymbolTable::InsertMethodSymbol(MethodSymbol *method_symbol)
  1949. {
  1950. assert(base);
  1951.     AddMethodSymbol(method_symbol);
  1952.  
  1953.     int k = method_symbol -> name_symbol -> index % hash_size;
  1954.     method_symbol -> next = base[k];
  1955.     base[k] = method_symbol;
  1956.  
  1957.     //
  1958.     // If the set is "adjustable" and the number of unique elements in it exceeds
  1959.     // 2 times the size of the base, and we have not yet reached the maximum
  1960.     // allowable size for a base, reallocate a larger base and rehash the elements.
  1961.     //
  1962.     if ((hash_size < MAX_HASH_SIZE) && (Size() > (hash_size << 1)))
  1963.         Rehash();
  1964.  
  1965.     return;
  1966. }
  1967.  
  1968.  
  1969. inline void TypeSymbol::InsertMethodSymbol(MethodSymbol *method_symbol)
  1970. {
  1971.     Table() -> InsertMethodSymbol(method_symbol);
  1972. }
  1973.  
  1974.  
  1975. inline void SymbolTable::InsertConstructorSymbol(MethodSymbol *method_symbol)
  1976. {
  1977. assert(! constructor);
  1978.     this -> constructor = method_symbol;
  1979.     InsertMethodSymbol(method_symbol);
  1980. }
  1981.  
  1982.  
  1983. inline void TypeSymbol::InsertConstructorSymbol(MethodSymbol *method_symbol)
  1984. {
  1985.     Table() -> InsertConstructorSymbol(method_symbol);
  1986. }
  1987.  
  1988.  
  1989. inline MethodSymbol *SymbolTable::FindMethodSymbol(NameSymbol *name_symbol)
  1990. {
  1991. assert(base);
  1992.     for (Symbol *symbol = base[name_symbol -> index % hash_size]; symbol; symbol = symbol -> next)
  1993.     {
  1994.         if (name_symbol == symbol -> Identity())
  1995.         {
  1996.             MethodSymbol *method = symbol -> MethodCast();
  1997.             if (method)
  1998.                 return method;
  1999.         }
  2000.     }
  2001.  
  2002.     return (MethodSymbol *) NULL;
  2003. }
  2004.  
  2005.  
  2006. inline MethodSymbol *TypeSymbol::FindMethodSymbol(NameSymbol *name_symbol)
  2007. {
  2008.     return (table ? table -> FindMethodSymbol(name_symbol) : (MethodSymbol *) NULL);
  2009. }
  2010.  
  2011.  
  2012. inline MethodSymbol *SymbolTable::FindConstructorSymbol()
  2013. {
  2014.     return this -> constructor;
  2015. }
  2016.  
  2017. inline MethodSymbol *TypeSymbol::FindConstructorSymbol()
  2018. {
  2019.     return (table ? table -> FindConstructorSymbol() : (MethodSymbol *) NULL);
  2020. }
  2021.  
  2022. inline VariableSymbol *SymbolTable::InsertVariableSymbol(NameSymbol *name_symbol)
  2023. {
  2024. assert(base);
  2025.     VariableSymbol *symbol = new VariableSymbol(name_symbol);
  2026.     AddVariableSymbol(symbol);
  2027.  
  2028.     int k = name_symbol -> index % hash_size;
  2029.     symbol -> next = base[k];
  2030.     base[k] = symbol;
  2031.  
  2032.     //
  2033.     // If the set is "adjustable" and the number of unique elements in it exceeds
  2034.     // 2 times the size of the base, and we have not yet reached the maximum
  2035.     // allowable size for a base, reallocate a larger base and rehash the elements.
  2036.     //
  2037.     if ((hash_size < MAX_HASH_SIZE) && (Size() > (hash_size << 1)))
  2038.         Rehash();
  2039.  
  2040.     return symbol;
  2041. }
  2042.  
  2043.  
  2044. inline VariableSymbol *TypeSymbol::InsertVariableSymbol(NameSymbol *name_symbol)
  2045. {
  2046.     return Table() -> InsertVariableSymbol(name_symbol);
  2047. }
  2048.  
  2049.  
  2050. inline VariableSymbol *BlockSymbol::InsertVariableSymbol(NameSymbol *name_symbol)
  2051. {
  2052.     return Table() -> InsertVariableSymbol(name_symbol);
  2053. }
  2054.  
  2055.  
  2056. inline void SymbolTable::InsertVariableSymbol(VariableSymbol *variable_symbol)
  2057. {
  2058. assert(base);
  2059.     AddVariableSymbol(variable_symbol);
  2060.  
  2061.     int k = variable_symbol -> name_symbol -> index % hash_size;
  2062.     variable_symbol -> next = base[k];
  2063.     base[k] = variable_symbol;
  2064.  
  2065.     //
  2066.     // If the set is "adjustable" and the number of unique elements in it exceeds
  2067.     // 2 times the size of the base, and we have not yet reached the maximum
  2068.     // allowable size for a base, reallocate a larger base and rehash the elements.
  2069.     //
  2070.     if ((hash_size < MAX_HASH_SIZE) && (Size() > (hash_size << 1)))
  2071.         Rehash();
  2072.  
  2073.     return;
  2074. }
  2075.  
  2076.  
  2077. inline void TypeSymbol::InsertVariableSymbol(VariableSymbol *variable_symbol)
  2078. {
  2079.     Table() -> InsertVariableSymbol(variable_symbol);
  2080. }
  2081.  
  2082.  
  2083. inline void BlockSymbol::InsertVariableSymbol(VariableSymbol *variable_symbol)
  2084. {
  2085.     Table() -> InsertVariableSymbol(variable_symbol);
  2086. }
  2087.  
  2088.  
  2089. inline VariableSymbol *SymbolTable::FindVariableSymbol(NameSymbol *name_symbol)
  2090. {
  2091. assert(base);
  2092.     for (Symbol *symbol = base[name_symbol -> index % hash_size]; symbol; symbol = symbol -> next)
  2093.     {
  2094.         if (name_symbol == symbol -> Identity())
  2095.         {
  2096.             VariableSymbol *variable_symbol = symbol -> VariableCast();
  2097.             if (variable_symbol)
  2098.                 return variable_symbol;
  2099.         }
  2100.     }
  2101.  
  2102.     return (VariableSymbol *) NULL;
  2103. }
  2104.  
  2105.  
  2106. inline VariableSymbol *TypeSymbol::FindVariableSymbol(NameSymbol *name_symbol)
  2107. {
  2108.     return (table ? table -> FindVariableSymbol(name_symbol) : (VariableSymbol *) NULL);
  2109. }
  2110.  
  2111.  
  2112. inline VariableSymbol *BlockSymbol::FindVariableSymbol(NameSymbol *name_symbol)
  2113. {
  2114.     return (table ? table -> FindVariableSymbol(name_symbol) : (VariableSymbol *) NULL);
  2115. }
  2116.  
  2117.  
  2118. inline LabelSymbol *SymbolTable::InsertLabelSymbol(NameSymbol *name_symbol)
  2119. {
  2120. assert(base);
  2121.     LabelSymbol *symbol = new LabelSymbol(name_symbol);
  2122.     AddOtherSymbol(symbol);
  2123.  
  2124.     int k = name_symbol -> index % hash_size;
  2125.     symbol -> next = base[k];
  2126.     base[k] = symbol;
  2127.  
  2128.     //
  2129.     // as only one label can be inserted in any given symboltable,
  2130.     // we don't need to try to rehash here !
  2131.     //
  2132.  
  2133.     return symbol;
  2134. }
  2135.  
  2136.  
  2137. inline LabelSymbol *SymbolTable::FindLabelSymbol(NameSymbol *name_symbol)
  2138. {
  2139. assert(base);
  2140.     for (Symbol *symbol = base[name_symbol -> index % hash_size]; symbol; symbol = symbol -> next)
  2141.     {
  2142.         if (name_symbol == symbol -> Identity())
  2143.         {
  2144.             LabelSymbol *label = symbol -> LabelCast();
  2145.             if (label)
  2146.                 return label;
  2147.         }
  2148.     }
  2149.  
  2150.     return (LabelSymbol *) NULL;
  2151. } 
  2152.  
  2153. inline BlockSymbol *SymbolTable::InsertBlockSymbol(int hash_size = 0)
  2154. {
  2155.     BlockSymbol *symbol = new BlockSymbol(hash_size);
  2156.     AddOtherSymbol(symbol);
  2157.  
  2158.     return symbol;
  2159. }
  2160.  
  2161.  
  2162. inline BlockSymbol *BlockSymbol::InsertBlockSymbol(int hash_size = 0)
  2163. {
  2164.     return Table() -> InsertBlockSymbol(hash_size);
  2165. }
  2166.  
  2167.  
  2168. inline MethodSymbol *SymbolTable::Overload(MethodSymbol *base_method)
  2169. {
  2170.     MethodSymbol *overload = new MethodSymbol(base_method -> Identity());
  2171.     AddMethodSymbol(overload);
  2172.  
  2173.     overload -> next = overload; // mark overloaded method
  2174.     overload -> next_method = base_method -> next_method;
  2175.     base_method -> next_method = overload;
  2176.  
  2177.     return overload;
  2178. }
  2179.  
  2180.  
  2181. inline MethodSymbol *TypeSymbol::Overload(MethodSymbol *base_method)
  2182. {
  2183. assert(table);
  2184.     return table -> Overload(base_method);
  2185. }
  2186.  
  2187.  
  2188. inline void SymbolTable::Overload(MethodSymbol *base_method, MethodSymbol *overload)
  2189. {
  2190.     AddMethodSymbol(overload);
  2191.  
  2192.     overload -> next = overload; // mark overloaded method
  2193.     overload -> next_method = base_method -> next_method;
  2194.     base_method -> next_method = overload;
  2195.  
  2196.     return;
  2197. }
  2198.  
  2199. inline void TypeSymbol::Overload(MethodSymbol *base_method, MethodSymbol *overload)
  2200. {
  2201. assert(table);
  2202.     table -> Overload(base_method, overload);
  2203. }
  2204.  
  2205.  
  2206. inline MethodSymbol *SymbolTable::LocalConstructorOverload(MethodSymbol *base_method)
  2207. {
  2208.     MethodSymbol *overload = new MethodSymbol(base_method -> Identity());
  2209.     AddMethodSymbol(overload);
  2210.  
  2211.     overload -> next = overload; // mark overloaded method
  2212.     overload -> SetGeneratedLocalConstructor(base_method);
  2213.  
  2214.     return overload;
  2215. }
  2216.  
  2217.  
  2218. inline MethodSymbol *TypeSymbol::LocalConstructorOverload(MethodSymbol *base_method)
  2219. {
  2220. assert(table);
  2221.     return table -> LocalConstructorOverload(base_method);
  2222. }
  2223.  
  2224.  
  2225. inline MethodSymbol *TypeSymbol::FindOverloadMethod(MethodSymbol *base_method, AstMethodDeclarator *method_declarator)
  2226. {
  2227.     return (table ? table -> FindOverloadMethod(base_method, method_declarator) : (MethodSymbol *) NULL);
  2228. }
  2229.  
  2230.  
  2231. inline SymbolTable *DirectorySymbol::Table()
  2232. {
  2233.     return (table ? table : table = new SymbolTable(101));
  2234. }
  2235.  
  2236. inline SymbolTable *PackageSymbol::Table()
  2237. {
  2238.     return (table ? table : table = new SymbolTable(101));
  2239. }
  2240.  
  2241. inline void TypeSymbol::SetSymbolTable(int estimate)
  2242. {
  2243.     if (! table) // If table was not yet allocated, allocate one based on the estimate
  2244.         table = new SymbolTable(estimate);
  2245. }
  2246.  
  2247. inline SymbolTable *TypeSymbol::Table()
  2248. {
  2249.     return (table ? table : table = new SymbolTable());
  2250. }
  2251.  
  2252. inline SymbolTable *BlockSymbol::Table()
  2253. {
  2254.     return (table ? table : table = new SymbolTable());
  2255. }
  2256.  
  2257. #ifdef UNIX_FILE_SYSTEM
  2258.     inline bool FileSymbol::IsClassSuffix(char *suffix)
  2259.     {
  2260.         return (strncmp(suffix, class_suffix, class_suffix_length) == 0);
  2261.     }
  2262.  
  2263.     inline bool  FileSymbol::IsJavaSuffix(char *suffix)
  2264.     {
  2265.         return (strncmp(suffix, java_suffix, java_suffix_length) == 0);
  2266.     }
  2267. #elif defined(WIN32_FILE_SYSTEM)
  2268.     inline bool FileSymbol::IsClassSuffix(char *suffix)
  2269.     {
  2270.         return Case::StringSegmentEqual(suffix, class_suffix, class_suffix_length);
  2271.     }
  2272.  
  2273.     inline bool  FileSymbol::IsJavaSuffix(char *suffix)
  2274.     {
  2275.         return Case::StringSegmentEqual(suffix, java_suffix, java_suffix_length);
  2276.     }
  2277. #elif defined(AMIGAOS_FILE_SYSTEM)
  2278.     // Do not use StringSegmentEqual() as in the WIN32 case, because that
  2279.     // function may check beyond the end of the string, thus possibly causing
  2280.     // enforcer hits.
  2281.     inline bool FileSymbol::IsClassSuffix(char *suffix)
  2282.     {
  2283.         return (strncasecmp(suffix, class_suffix, class_suffix_length) == 0);
  2284.     }
  2285.  
  2286.     inline bool  FileSymbol::IsJavaSuffix(char *suffix)
  2287.     {
  2288.         return (strncasecmp(suffix, java_suffix, java_suffix_length) == 0);
  2289.     }
  2290. #endif
  2291.  
  2292. #endif // ifndef symbol_INCLUDED
  2293.